home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 3 / Cream of the Crop 3.iso / comm / wnos5src.zip / SCC.C < prev    next >
C/C++ Source or Header  |  1993-11-21  |  54KB  |  1,433 lines
  1. /* Generic driver for Z8530 boards, modified from the PE1CHL
  2.  * driver for use with NOS. This version also supports the NRS
  3.  * mode when used as an asynch port. Device setup is similar to
  4.  * that of the PE1CHL version, with the addition of user specification
  5.  * of buffer size (bufsize). See the file "scc.txt" for general
  6.  * information on the use of this driver and setup procedures.
  7.  *
  8.  * General differences between this driver and the original version:
  9.  *
  10.  * 1) Slip encoding and decoding is not done in the driver, but
  11.  *    using the routines in slip.c, and these routines are supported
  12.  *    in a manner similar to the asynch routines for the 8250. The
  13.  *    input is handled via fifo buffer, while output is direct. The
  14.  *    routines scc_send and get_scc are called via pointers in the
  15.  *    Slip and Nrs structs for the parcticular channel.
  16.  *
  17.  * 2) The timer routine, scctim, is not installed directly in the
  18.  *    timer interrupt chain, but is called through the systick routine
  19.  *    in pc.c.
  20.  *
  21.  * 3) Facilities of nos are used whenever possible in place of direct
  22.  *    structure or variable manipulation. Mbuf management is handled
  23.  *    this way, along with interface initialization.
  24.  *
  25.  * 4) Nrs mode support is added in a manner similar to that of the
  26.  *    Slip support. I have not had an opportunity to test this, but
  27.  *    it is essentially identical to the way the 8250 version works.
  28.  *
  29.  * 5) Callsign specification on radio modes (kiss,nrs,ax25) is an
  30.  *    option. If not supplied, the value of Mycall will be used.
  31.  *
  32.  * 6) Bufsize specification is now a parameter on setup of each channel.
  33.  *    This is the size of the fifo on asynch input, and the size of
  34.  *    mbuf buffers for sdlc mode. Since the fifo buffer can fill up,
  35.  *    this value should be reasonably large for asynch mode. Mbufs
  36.  *    are chained when they fill up, so having a small bufsize with
  37.  *    sdlc modes (ax25) does not result in loss of characters.
  38.  *
  39.  * 7) Because slip and nrs decoding is handled outside the driver,
  40.  *    sccstat cannot be used to report sent and receive packet counts
  41.  *    in asynch mode, and these fields are blanked on display in asynch
  42.  *    modes.
  43.  *
  44.  *
  45.  * I am interested in setting up some default initializations for
  46.  * the popular Z8530 boards, to minimize user problems in constructing
  47.  * the proper attach init entries. These would allow for shortened
  48.  * entries to use the defaults, such as "attach scc 1 init drsi" to
  49.  * attach a DRSI board in standard configuration at its default address.
  50.  * Since I do not have complete technical information on all such boards,
  51.  * I would very much appreciate any information that users can provide
  52.  * me regarding particular boards.
  53.  *
  54.  * 1/25/90
  55.  *
  56.  * Modifications:
  57.  *
  58.  * 2/17/90:
  59.  *
  60.  * 1) Added mods from PE1CHL which reflect relevent changes to the
  61.  *    scc driver in his version of net between 10/89 and 1/90. Changes
  62.  *    incorporated include additional delays in sccvec.asm, addition
  63.  *    of external clock mode, and initialization for the 8536 as a
  64.  *    clock divider on the DRSI board. "INLINE" is a slight delay
  65.  *    for register access incorporated for use with the inline i/o
  66.  *    code in MSC. This may not be useful or necessary with TURBO.
  67.  *    Changes making "TPS" a variable were not added, since the
  68.  *    scc timer does not install itself on the hardware interrupt
  69.  *    in this version.
  70.  *
  71.  *
  72.  * Ken Mitchum, KY3B       km@cs.pitt.edu  km@dsl.pitt.edu
  73.  *                             or mail to the tcpip group
  74.  *
  75.  *
  76.  * 5/07/92:
  77.  *
  78.  * 1) Changes needed for BayCom-USCC card were made. CTS-Interrupt
  79.  *    was disabled, because it keeps the system hanging. Clock sources
  80.  *    will be changed when transmitter is switched on/off, if internal
  81.  *    clock is used. Now DF9IC's G3RUH compatible modem is supported,
  82.  *    which needs NRZ-signals and provides external clocks.
  83.  *
  84.  * René Stange, DG0FT @DB0KG.DEU.EU
  85.  *
  86.  */
  87.  
  88. /* Added ANSI-style prototypes, reformatted source, minor delinting.
  89.  * Integrated into standard 900201 NOS by KA9Q.
  90.  */
  91.  
  92. /*
  93.  * Generic driver for Z8530 SCC chip in SLIP, KISS or AX.25 mode.
  94.  *
  95.  * Written by R.E. Janssen (PE1CHL) using material from earlier
  96.  * EAGLE and PC100 drivers in this package.
  97.  *
  98.  * The driver has initially been written for my own Atari SCC interface
  99.  * board, but it could eventually replace the other SCC drivers.
  100.  *
  101.  * Unfortunately, there is little consistency between the different interface
  102.  * boards, as to the use of a clock source, the solution for the fullduplex
  103.  * clocking problem, and most important of all: the generation of the INTACK
  104.  * signal.    Most designs do not even support the generation of an INTACK and
  105.  * the read of the interrupt vector provided by the chip.
  106.  * This results in lots of configuration parameters, and a fuzzy
  107.  * polltable to be able to support multiple chips connected at one interrupt
  108.  * line...
  109.  *
  110.  */
  111.  
  112.  
  113. #include <stdlib.h>
  114. #include <stdio.h>
  115. #include <ctype.h>
  116. #include <time.h>
  117. #include <dos.h>
  118. #include "global.h"
  119. #include "config.h"
  120. #ifdef SCC
  121. #include "mbuf.h"
  122. #include "netuser.h"
  123. #include "proc.h"
  124. #include "iface.h"
  125. #include "pktdrvr.h"
  126. #include "slip.h"
  127. #ifdef NRS
  128. #include "nrs.h"
  129. #endif
  130. #include "n8250.h"
  131. #include "scc.h"
  132. #include "n8530.h"
  133. #include "n8536.h"
  134. #include "ax25.h"
  135. #include "trace.h"
  136. #include "pc.h"
  137. #include "kiss.h"
  138. #include "devparam.h"
  139.  
  140. /* interrupt handlers */
  141. extern INTERRUPT sccvec();
  142. extern INTERRUPT sccnovec();
  143.  
  144. /* variables used by the SCC interrupt handler in sccvec.asm */
  145. static INTERRUPT (*Orgivec)();          /* original interrupt vector */
  146.  
  147. struct sccinfo Sccinfo = {0};           /* global info about SCCs */
  148. struct sccchan *Sccchan[2 * MAXSCC] = {0}; /* information per channel */
  149. ioaddr Sccvecloc = {0};                 /* location to access for SCC vector */
  150. unsigned char Sccmaxvec = {0};          /* maximum legal vector from SCC */
  151. ioaddr Sccpolltab[MAXSCC+1][2] = {0};    /* polling table when no vectoring */
  152.  
  153. #if defined(INLINE)
  154. static unsigned scc_delay(unsigned v)   /* delay for about 5 PCLK cycles */
  155.                                         /* pass-through used for input */
  156. {
  157.    int i,j;                             /* it takes time to save them */
  158.    return v;                            /* return the passed parameter */
  159. }
  160. #endif
  161.  
  162. static unsigned char Random = 0;            /* random number for p-persist */
  163. static int hsize = sizeof(struct phdr);     /* size of the pseudo-header */
  164.  
  165. #define z 0
  166.  
  167. static int scc_raw __ARGS((struct iface *ifp,struct mbuf *bp));
  168. static int scc_stop __ARGS((struct iface *ifp,int tmp));
  169. static int scc_send __ARGS((int dev,struct mbuf *bp));
  170.  
  171. static int32 scc_aioctl __ARGS((struct iface *ifp,int cmd,int set,int32 val));
  172. static int32 scc_sioctl __ARGS((struct iface *ifp,int cmd,int set,int32 val));
  173.  
  174. /* set SCC channel speed
  175.  * clkmode specifies the division rate (1,16,32) inside the SCC
  176.  * returns the selected brgrate for "real speed" calculation
  177.  */
  178. static unsigned int
  179. scc_speed(struct sccchan *scc,unsigned int clkmode,long speed)
  180. {
  181.     long spdclkm = speed * clkmode;
  182.  
  183.     /* calculate baudrate generator value */
  184.     if(spdclkm == 0) {
  185.         return 65000U;        /* avoid divide-by-zero */
  186.     } else {
  187.         unsigned int brgrate = (unsigned)((Sccinfo.clk + spdclkm) / (spdclkm * 2)) - 2;
  188.  
  189.         DISABLE();
  190.  
  191.         cl(scc,R14,BRENABL);        /* disable baudrate generator */
  192.         wr(scc,R12,brgrate);        /* brg rate LOW */
  193.         wr(scc,R13,brgrate >> 8);        /* brg rate HIGH */
  194.         or(scc,R14,BRENABL);        /* enable baudrate generator */
  195.  
  196.         RESTORE();
  197.         return brgrate;
  198.     }
  199. }
  200.  
  201. /* Switch the SCC to "receive" mode (or: switch off transmitter)
  202.  * Only to be called from an interrupt handler, while in AX.25 mode */
  203. static void
  204. scc_txoff(struct sccchan *scc)
  205. {
  206.     cl(scc,R5,RTS);                             /* turn off RTS line */
  207.  
  208.     if(Sccinfo.hwtype & HWPRIMUS) {             /* PRIMUS has another PTT bit... */
  209.         WRREG(scc->ctrl + 4,Sccinfo.hwparam);   /* clear that bit! */
  210.     }
  211.     if(!scc->fulldup && !scc->extclock) {       /* no fulldup divider? */
  212.         cl(scc,R5,TxENAB);                      /* then disable the transmitter */
  213.         scc_speed(scc,32,scc->speed);           /* back to receiver baudrate */
  214.         /* DPLL -> Rx clk, DPLL -> Tx CLK, RxCLK -> TRxC pin */
  215.         wr(scc,R11,RCDPLL|TCDPLL|TRxCOI|TRxCDP);
  216.         or(scc,R3,ENT_HM|RxENABLE);             /* enable the receiver, hunt mode */
  217.     }
  218. }
  219.  
  220. /* Throw away receive mbuf(s) when an error occurred */
  221. static void
  222. scc_tossb (struct sccchan *scc)
  223. {
  224.     struct mbuf *bp = scc->rbp;
  225.  
  226.     if(bp != NULLBUF) {
  227.         free_p(bp->next);
  228.         free_p(bp->dup);                    /* Should be NULLBUF */
  229.         bp->next = NULLBUF;
  230.         scc->rbp1 = bp;                     /* Don't throw this one away */
  231.         bp->cnt = hsize;                    /* Simply rewind it */
  232.     } 
  233. }
  234.  
  235. /* Blocking read from asynch input.
  236.  * Essentially the same as get_asy() in 8250.c
  237.  * See comments in asy_rxint().
  238.  */
  239. static int
  240. get_scc(int dev)
  241. {
  242.     int c;
  243.     struct fifo *fp = &Sccchan[dev]->fifo;
  244.  
  245.     DISABLE();
  246.  
  247.     while(fp->cnt == 0) {
  248.         if(pwait(fp) != 0) {
  249.             RESTORE();
  250.             return -1;
  251.         }
  252.     }
  253.     fp->cnt--;
  254.  
  255.     RESTORE();
  256.  
  257.     c = *fp->rp++;
  258.  
  259.     if(fp->rp >= &fp->buf[fp->bufsize]) {
  260.         fp->rp = fp->buf;
  261.     }
  262.     return c;
  263. }
  264.  
  265. /* --START--------- Interrupt handlers for sdlc mode (AX.25) --------START-- */
  266. /* Transmitter interrupt handler */
  267. static void
  268. scc_sdlctx(struct sccchan *scc)
  269. {
  270.     struct mbuf *bp;
  271.  
  272.     scc->txints++;
  273.  
  274.     switch(scc->a.tstate) {                     /* look at transmitter state */
  275.     case ACTIVE:                                /* busy sending data bytes */
  276.         bp = scc->tbp;
  277.         while(bp->cnt == 0) {                     /* nothing left in this mbuf? */
  278.             bp = bp->next;                      /* save link to next */
  279.             free_mbuf(scc->tbp);                /*KM*/
  280.             if((scc->tbp = bp) == NULLBUF) {    /* see if more mbufs follow */
  281.                 if(RDREG(scc->ctrl) & TxEOM) {  /* check tx underrun status */
  282.                     scc->rovers++;              /* oops, an underrun! count them */
  283.                     WRREG(scc->ctrl,SEND_ABORT);    /* send an abort to be sure */
  284.                     scc->a.tstate = TAIL;       /* key down tx after TAILTIME */
  285.                     scc->timercount = scc->a.tailtime;
  286.                     return;
  287.                 }
  288.                 cl(scc,R10,ABUNDER);            /* frame complete, allow CRC transmit */
  289.                 scc->a.tstate = FLUSH;
  290.                 WRREG(scc->ctrl,RES_Tx_P);      /* reset pending int */
  291.                 return;
  292.             }
  293.         }
  294.         /* now bp = scc->tbp (either from while or from if stmt above) */
  295.         WRREG(scc->data,*(bp->data++));         /* send the character */
  296.         bp->cnt--;                              /* decrease mbuf byte count */
  297.         return;
  298.     case FLUSH:                                 /* CRC just went out, more to send? */
  299.         or(scc,R10,ABUNDER);                    /* re-install underrun protection */
  300.         /* verify that we are not exeeding max tx time (if defined) */
  301.         if((scc->timercount != 0
  302.           || scc->a.maxkeyup == 0)
  303.           &&(scc->tbp = scc->sndq) != NULLBUF) {    /* dequeue a frame */
  304.             scc->sndq = scc->sndq->anext;
  305.             WRREG(scc->ctrl,RES_Tx_CRC);        /* reset the TX CRC generator */
  306.             scc->a.tstate = ACTIVE;
  307.             scc_sdlctx(scc);                    /* write 1st byte */
  308.             WRREG(scc->ctrl,RES_EOM_L);         /* reset the EOM latch */
  309.             return;
  310.         }
  311.         scc->a.tstate = TAIL;                   /* no more, key down tx after TAILTIME */
  312.         scc->timercount = scc->a.tailtime;
  313. #ifdef XXX
  314.         WRREG(scc->ctrl,RES_Tx_P);
  315.         return;
  316. #endif        
  317.     default:                                    /* another state */
  318.         WRREG(scc->ctrl,RES_Tx_P);              /* then don't send anything */
  319.         return;
  320.     }
  321. }
  322.  
  323. /* External/Status interrupt handler */
  324. static void
  325. scc_sdlcex(struct sccchan *scc)
  326. {
  327.     unsigned char status = RDREG(scc->ctrl);
  328.     unsigned char changes = status ^ scc->status;
  329.  
  330.     scc->exints++;
  331.  
  332.     if(changes & BRK_ABRT) {                    /* Received an ABORT */
  333.         if(status & BRK_ABRT) {                 /* is this the beginning? */
  334.             if(scc->rbp != NULLBUF) {           /* did we receive something? */
  335.                 /* check if a significant amount of data came in */
  336.                 /* this is because the drop of DCD tends to generate an ABORT */
  337.                 if(scc->rbp->next != NULLBUF || scc->rbp->cnt > hsize) {
  338.                     scc->rxerrs++;              /* then count it as an error */
  339.                 }
  340.                 scc_tossb(scc);                 /* throw away buffer */
  341.             }
  342.             VOID(RDREG(scc->data));             /* flush the FIFO */
  343.             VOID(RDREG(scc->data));
  344.             VOID(RDREG(scc->data));
  345.         }
  346.     }
  347.     if(changes & CTS) {                         /* CTS input changed state */
  348.         if(status & CTS) {                      /* CTS is now ON */
  349.             if(scc->a.tstate == KEYWT && scc->a.txdelay == 0) {     /* zero TXDELAY = wait for CTS */
  350.                 scc->timercount = 1;            /* it will start within 10 ms */
  351.             }
  352.         }
  353.     }
  354.     if(changes & DCD) {                         /* DCD input changed state */
  355.         if(status & DCD) {                      /* DCD is now ON */
  356.             if(!scc->extclock) {
  357.                 WRSCC(scc->ctrl,R14,SEARCH|scc->wreg[R14]); /* DPLL: enter search mode */
  358.             }
  359.             or(scc,R3,ENT_HM|RxENABLE);         /* enable the receiver, hunt mode */
  360.         } else {                                /* DCD is now OFF */
  361.             cl(scc,R3,ENT_HM|RxENABLE);         /* disable the receiver */
  362.             VOID(RDREG(scc->data));             /* flush the FIFO */
  363.             VOID(RDREG(scc->data));
  364.             VOID(RDREG(scc->data));
  365.             if(scc->rbp != NULLBUF) {           /* did we receive something? */
  366.                 /* check if a significant amount of data came in */
  367.                 /* this is because some characters precede the drop of DCD */
  368.                 if(scc->rbp->next != NULLBUF || scc->rbp->cnt > hsize) {
  369.                     scc->rxerrs++;              /* then count it as an error */
  370.                 }
  371.                 scc_tossb(scc);                 /* throw away buffer */
  372.             }
  373.         }
  374.     }
  375.     scc->status = status;
  376.     WRREG(scc->ctrl,RES_EXT_INT);
  377. }
  378.  
  379. /* Receiver interrupt handler */
  380. static void
  381. scc_sdlcrx(struct sccchan *scc)
  382. { 
  383.     struct mbuf *bp = scc->rbp1;
  384.     
  385.     if(bp == NULLBUF) {                 /* no buffer available now */
  386.         if(scc->rbp == NULLBUF) {
  387.             bp = scc->rbp = scc->rbp1 = alloc_mbuf(scc->bufsiz + hsize);
  388.             bp->cnt = hsize;
  389.         } else {
  390.             for(bp = scc->rbp; bp->next != NULLBUF; bp = bp->next) ;
  391.             bp = bp->next = scc->rbp1 = alloc_mbuf(scc->bufsiz);
  392.         }
  393.         if(bp == NULLBUF) {
  394.             VOID(RDREG(scc->data));     /* so we have to discard the char */
  395.             or(scc,R3,ENT_HM);          /* enter hunt mode for next flag */
  396.             scc_tossb(scc);             /* put buffers back on pool */
  397.             scc->nospace++;             /* count these events */
  398.             return;
  399.         }
  400.     }
  401.     /* now, we have a buffer (at bp). read character and store it */
  402.     bp->data[bp->cnt++] = RDREG(scc->data);
  403.  
  404.     if(bp->cnt == bp->size) {           /* buffer full? */
  405.         scc->rbp1 = NULLBUF;            /* acquire a new one next time */
  406.     }
  407.     scc->rxints++;
  408. }
  409.  
  410. /* Receive Special Condition interrupt handler */
  411. static void
  412. scc_sdlcsp(struct sccchan *scc)
  413. {
  414.     struct mbuf *bp;
  415.     struct phdr *ph;
  416.  
  417.     unsigned char status = rd(scc,R1);          /* read receiver status */
  418.  
  419.     scc->spints++;
  420.     VOID(RDREG(scc->data));                     /* flush offending character */
  421.  
  422.     if(status & Rx_OVR) {                       /* receiver overrun */ 
  423.         scc->rovers++;                          /* count them */ 
  424.         or(scc,R3,ENT_HM);                      /* enter hunt mode for next flag */ 
  425.         scc_tossb(scc);                         /* rewind the buffer and toss */ 
  426.     } 
  427.     if(status & END_FR                          /* end of frame */ 
  428.       && scc->rbp != NULLBUF) {                 /* at least received something */ 
  429.         if((status & CRC_ERR) == 0              /* no CRC error is indicated */ 
  430.           && (status & 0xe) == RES8             /* 8 bits in last byte */ 
  431.           && scc->rbp->cnt > hsize) {           
  432.             /* we seem to have a good frame. but the last byte received */ 
  433.             /* from rx interrupt is in fact a CRC byte, so discard it */ 
  434.             if(scc->rbp1 != NULLBUF) { 
  435.                 scc->rbp1->cnt--;               /* current mbuf was not full */ 
  436.             } else { 
  437.                 /* find last mbuf */ 
  438.                 for(bp = scc->rbp; bp->next != NULLBUF; bp = bp->next) ;
  439.                 bp->cnt--;                      /* last byte is first CRC byte */ 
  440.             } 
  441.             ph = (struct phdr *)scc->rbp->data; 
  442.             ph->iface = scc->iface; 
  443.             ph->type = CL_AX25; 
  444.             enqueue(&Hopper,scc->rbp); 
  445.             scc->rbp = scc->rbp1 = NULLBUF;
  446.             scc->rxframes++; 
  447.         } else {                                /* a bad frame */ 
  448.             scc_tossb(scc);                     /* throw away frame */
  449.             scc->rxerrs++; 
  450.         } 
  451.     } 
  452.     WRREG(scc->ctrl,ERR_RES); 
  453. }
  454. /* ---END--------- Interrupt handlers for sdlc mode (AX.25) ----------END-- */
  455.  
  456.  
  457. /* --START- Interrupt handlers for asynchronous modes (kiss, slip) -START-- */
  458. /* Transmitter interrupt handler */
  459. /* This routine sends data from mbufs in SLIP format */
  460. static void
  461. scc_asytx(struct sccchan *scc)
  462. {
  463.     struct mbuf *bp;
  464.  
  465.     scc->txints++;
  466.  
  467.     if(scc->txchar != 0) {              /* a character pending for transmit? */
  468.         WRREG(scc->data,scc->txchar);   /* send it now */
  469.         scc->txchar = 0;                /* next time, ignore it */
  470.         return;
  471.     }
  472.     if(scc->tbp == NULLBUF) {           /* nothing to send? */
  473.         if((scc->tbp = scc->sndq) != NULLBUF) {     /* dequeue next frame */
  474.             scc->sndq = scc->sndq->anext;
  475.             WRREG(scc->data,FR_END);    /* send FR_END to flush line garbage */
  476.         } else {
  477.             WRREG(scc->ctrl,RES_Tx_P);  /* else only reset pending int */
  478.         }
  479.         return;
  480.     }
  481.     bp = scc->tbp;
  482.  
  483.     while(bp->cnt == 0) {                  /* nothing left in this mbuf? */
  484.         bp = bp->next;                  /* save link to next */
  485.         free_mbuf(scc->tbp);
  486.  
  487.         if((scc->tbp = bp) == NULLBUF){ /* see if more mbufs follow */
  488.             WRREG(scc->data,FR_END);    /* frame complete, send FR_END */
  489.             return;
  490.         }
  491.     }
  492.     /* now bp = scc->tbp (either from while or from if stmt above) */
  493.  
  494.     WRREG(scc->data,*(bp->data));       /* just send the character */
  495.     bp->cnt--;                          /* decrease mbuf byte count */
  496.     bp->data++;                         /* and increment the data pointer */
  497. }
  498.  
  499. /* External/Status interrupt handler */
  500. static void
  501. scc_asyex(struct sccchan *scc)
  502. {
  503.     unsigned char status = RDREG(scc->ctrl);
  504.     unsigned char changes = status ^ scc->status;
  505.  
  506.     scc->exints++;
  507.  
  508.     if(changes & BRK_ABRT) {            /* BREAK? */
  509.         if((status & BRK_ABRT) == 0)    /* BREAK now over? */
  510.             VOID(RDREG(scc->data));     /* read the NUL character */
  511.     }
  512.     scc->status = status;
  513.     WRREG(scc->ctrl,RES_EXT_INT);
  514. }
  515.  
  516. /* Receiver interrupt handler under NOS.
  517.  * Since the higher serial protocol routines are all written to work
  518.  * well with the routines in 8250.c, it makes sense to handle
  519.  * asynch i/o with the 8530 in a similar manner. Therefore, these
  520.  * routines are as close to their counterparts in 8250.c as possible.
  521.  */
  522. static void
  523. scc_asyrx(struct sccchan *scc)
  524. {
  525.     struct fifo *fp = &(scc->fifo);
  526.  
  527.     scc->rxints++;
  528.  
  529.     do {
  530.         char c = RDREG(scc->data);
  531.         if(fp->cnt != fp->bufsize){
  532.             *fp->wp++ = c;
  533.             if(fp->wp >= &fp->buf[fp->bufsize])
  534.                 fp->wp = fp->buf;
  535.             fp->cnt++;
  536.         } else
  537.             scc->nospace++;
  538.     } while(RDREG(scc->ctrl) & Rx_CH_AV);
  539.     
  540.     psignal(fp,1);              /* eventually move this to timer routine */
  541. }
  542.  
  543. /* Receive Special Condition interrupt handler */
  544. static void
  545. scc_asysp(struct sccchan *scc)
  546. {
  547.     unsigned char status = rd(scc,R1);      /* read receiver status */
  548.  
  549.     scc->spints++;
  550.  
  551.     VOID(RDREG(scc->data));                 /* flush offending character */
  552.  
  553.     if(status & (CRC_ERR | Rx_OVR)) {       /* did a framing error or overrun occur ? */
  554.         scc->rovers++;                      /* report as overrun */
  555.     }
  556.     WRREG(scc->ctrl,ERR_RES);
  557. }
  558. /* ---END-- Interrupt handlers for asynchronous modes (kiss, slip) ---END-- */
  559.  
  560. /* initialize an SCC channel in SDLC mode */
  561. static void near
  562. scc_sdlc(struct sccchan *scc)
  563. {
  564.     scc->int_transmit = scc_sdlctx;         /* set interrupt handlers */
  565.     scc->int_extstat = scc_sdlcex;
  566.     scc->int_receive = scc_sdlcrx;
  567.     scc->int_special = scc_sdlcsp;
  568.  
  569.     DISABLE();
  570.  
  571.     wr(scc,R4,X1CLK|SDLC);                  /* *1 clock, SDLC mode */
  572.     wr(scc,R1,z);                           /* no W/REQ operation */
  573.     wr(scc,R3,Rx8|RxCRC_ENAB);              /* RX 8 bits/char, CRC, disabled */
  574.     wr(scc,R5,Tx8|DTR|TxCRC_ENAB);          /* TX 8 bits/char, disabled, DTR */
  575.     wr(scc,R6,z);                           /* SDLC address zero (not used) */
  576.     wr(scc,R7,FLAG);                        /* SDLC flag value */
  577.     wr(scc,R9,VIS);                         /* vector includes status */
  578.  
  579.     if(scc->extclock) {                     /* when using external clocks */
  580.         if(Sccinfo.hwtype & HWBAYCOM) {     /* DF9IC-modem? */
  581.             wr(scc,R10,CRCPS|NRZ|ABUNDER);    /* CRC preset 1, select NRZ, ABORT on underrun */
  582.             wr(scc,R11,RCTRxCP|TCRTxCP);    /* RXclk TRxC, TXclk RTxC. */
  583.         } else {
  584.             wr(scc,R10,CRCPS|NRZI|ABUNDER);    /* CRC preset 1, select NRZI, ABORT on underrun */
  585.             wr(scc,R11,RCRTxCP|TCTRxCP);    /* RXclk RTxC, TXclk TRxC. */
  586.         }
  587.         wr(scc,R14,z);                      /* No BRG options */
  588.         WRSCC(scc->ctrl,R14,DISDPLL|scc->wreg[R14]);    /* No DPLL operation */
  589.     } else {
  590.         wr(scc,R10,CRCPS|NRZI|ABUNDER);     /* CRC preset 1, select NRZI, ABORT on underrun */
  591.  
  592.         if(scc->fulldup) {                   /* when external clock divider */
  593.             if(Sccinfo.pclk) {               /* when using PCLK as clock source */
  594.                 if (Sccinfo.hwtype & HWBAYCOM) {
  595.                     /* RXclk DPLL, TXclk RTxC, out=DPLL (Echo duplex) */
  596.                     wr(scc,R11,RCDPLL|TCRTxCP|TRxCOI|TRxCDP);
  597.                 } else {
  598.                     /* RXclk DPLL, TXclk RTxC, out=BRG. external /32 TRxC->RTxC */
  599.                     wr(scc,R11,RCDPLL|TCRTxCP|TRxCOI|TRxCBR);
  600.                 }
  601.             } else {
  602.                 /* RXclk DPLL, TXclk TRxC.    external TX clock to TRxC */
  603.                 wr(scc,R11,RCDPLL|TCTRxCP);
  604.             }
  605.         } else {                            /* only half-duplex operation */
  606.             /* RXclk DPLL, TXclk BRG. BRG reprogrammed at every TX/RX switch */
  607. #ifdef    notdef                                /* KA9Q - for PSK modem */
  608.             wr(scc,R11,RCDPLL|TCBR);
  609. #else
  610.             /* DPLL -> Rx clk, (DPLL -> Tx CLK), DPLL -> TRxC pin */
  611.             wr(scc,R11,RCDPLL|TCDPLL|TRxCOI|TRxCDP);
  612. #endif
  613.         }
  614.         wr(scc,R14,Sccinfo.pclk? BRSRC:z);       /* BRG source = PCLK/RTxC */
  615.         WRSCC(scc->ctrl,R14,SSBR|scc->wreg[R14]);  /* DPLL source = BRG */
  616.         WRSCC(scc->ctrl,R14,SNRZI|scc->wreg[R14]); /* DPLL NRZI mode */
  617.     }
  618.     if (Sccinfo.hwtype & HWBAYCOM) {         /* BayCom-USCC card? */
  619.         wr(scc,R15,BRKIE|DCDIE);            /* enable ABORT, DCD interrupts */
  620.     } else {
  621.         wr(scc,R15,BRKIE|CTSIE|DCDIE);      /* enable ABORT, CTS & DCD interrupts */
  622.     }
  623.     if(RDREG(scc->ctrl) & DCD) {            /* DCD is now ON */
  624.         if (!scc->extclock) {
  625.             WRSCC(scc->ctrl,R14,SEARCH|scc->wreg[R14]); /* DPLL: enter search mode */
  626.         }
  627.         or(scc,R3,ENT_HM|RxENABLE);            /* enable the receiver, hunt mode */
  628.     }
  629.     WRREG(scc->ctrl,RES_EXT_INT);            /* reset ext/status interrupts */
  630.     WRREG(scc->ctrl,RES_EXT_INT);            /* must be done twice */
  631.     scc->status = RDREG(scc->ctrl);            /* read initial status */
  632.  
  633.     or(scc,R1,INT_ALL_Rx|TxINT_ENAB|EXT_INT_ENAB); /* enable interrupts */
  634.     or(scc,R9,MIE);                            /* master interrupt enable */
  635.  
  636.     RESTORE();
  637. }
  638.  
  639. /* initialize an SCC channel in asynchronous mode */
  640. static int near
  641. scc_async(struct sccchan *scc)
  642. {
  643.     struct fifo *fp = &(scc->fifo);
  644.  
  645.     fp->buf = mxallocw(scc->bufsiz);
  646.     fp->bufsize = scc->bufsiz;
  647.     fp->wp = fp->rp = fp->buf;
  648.  
  649.     scc->int_transmit = scc_asytx;      /* set interrupt handlers */
  650.     scc->int_extstat = scc_asyex;
  651.     scc->int_receive = scc_asyrx;
  652.     scc->int_special = scc_asysp;
  653.  
  654.     DISABLE();
  655.  
  656.     wr(scc,R4,X16CLK|SB1);              /* *16 clock, 1 stopbit, no parity */
  657.     wr(scc,R1,z);                       /* no W/REQ operation */
  658.     wr(scc,R3,Rx8);                     /* RX 8 bits/char, disabled */
  659.     wr(scc,R5,Tx8|DTR|RTS);             /* TX 8 bits/char, disabled, DTR RTS */
  660.     wr(scc,R9,VIS);                     /* vector includes status */
  661.     wr(scc,R10,NRZ|z);                  /* select NRZ */
  662.     wr(scc,R11,RCBR|TCBR);              /* clocks are BR generator */
  663.     wr(scc,R14,Sccinfo.pclk? BRSRC:z);  /* brg source = PCLK/RTxC */
  664.     wr(scc,R15,BRKIE);                  /* enable BREAK ext/status int */
  665.  
  666.     or(scc,R3,RxENABLE);                /* enable receiver */
  667.     or(scc,R5,TxENAB);                  /* enable transmitter */
  668.  
  669.     WRREG(scc->ctrl,RES_EXT_INT);       /* reset ext/status interrupts */
  670.     WRREG(scc->ctrl,RES_EXT_INT);       /* must be done twice */
  671.     scc->status = RDREG(scc->ctrl);     /* read initial status */
  672.  
  673.     or(scc,R1,INT_ALL_Rx|TxINT_ENAB|EXT_INT_ENAB);  /* enable interrupts */
  674.     or(scc,R9,MIE);                     /* master interrupt enable */
  675.  
  676.     RESTORE();
  677.     return 0;
  678. }
  679.  
  680. /* SCC driver initialisation. called on "attach scc <num> init ..." */
  681. static int
  682. scc_init(int nchips,ioaddr iobase,int space,int aoff,int boff,int doff,ioaddr intack,int ivec,int32 clk,int pclk,int hwtype,int hwparam)
  683. {
  684.     int chip, chan, d, dum = 1;
  685.  
  686.     Sccinfo.init = 1;
  687.     Sccinfo.nchips = nchips;
  688.     Sccinfo.maxchan = (2 * nchips) - 1;
  689.     Sccinfo.iobase = iobase;
  690.     Sccinfo.space = space;
  691.     Sccinfo.off[0] = aoff;
  692.     Sccinfo.off[1] = boff;
  693.     Sccinfo.doff = doff;
  694.     Sccinfo.ivec = ivec;
  695.     Sccinfo.clk = clk;
  696.     Sccinfo.pclk = pclk;
  697.     Sccinfo.hwtype = hwtype;
  698.     Sccinfo.hwparam = hwparam;
  699.  
  700.     /* reset and pre-init all chips in the system */
  701.     for(chip = 0; chip < nchips; chip++) {
  702.         ioaddr chipbase = iobase + chip * space;
  703.         ioaddr ctrl = chipbase + Sccinfo.off[0];
  704.  
  705.         DISABLE();                              /* because of 2-step accesses */
  706.         
  707.         VOID(RDREG(ctrl));                      /* make sure pointer is written */
  708.         WRSCC(ctrl,R9,FHWRES);                  /* force hardware reset */
  709.         for (d = 0; d < 1000; d++) {            /* wait a while to be sure */
  710.             dum *= 10;
  711.         }
  712.         for(chan = 0; chan < 2; chan++) {
  713.             ctrl = chipbase + Sccinfo.off[chan];
  714.  
  715.             /* initialize a single channel to no-op */
  716.             VOID(RDREG(ctrl));                  /* make sure pointer is written */
  717.             WRSCC(ctrl,R4,z);                   /* no mode selected yet */
  718.             WRSCC(ctrl,R1,z);                   /* no W/REQ operation */
  719.             WRSCC(ctrl,R2,16 * chip);           /* chip# in upper 4 bits of vector */
  720.             WRSCC(ctrl,R3,z);                   /* disable rx */
  721.             WRSCC(ctrl,R5,z);                   /* disable tx */
  722.             WRSCC(ctrl,R9,VIS);                 /* vector includes status, MIE off */
  723.             Sccpolltab[chip][chan] = ctrl;      /* store ctrl addr for polling */
  724.         }
  725.         if(hwtype & HWEAGLE) {                  /* this is an EAGLE card */
  726.             WRREG(chipbase + 4,0x08);           /* enable interrupt on the board */
  727.         }
  728.         if(hwtype & HWPC100) {                  /* this is a PC100 card */
  729.             WRREG(chipbase,hwparam);            /* set the MODEM mode (22H normally) */
  730.         }
  731.         if(hwtype & HWPRIMUS) {                 /* this is a PRIMUS-PC */
  732.             WRREG(chipbase + 4,hwparam);        /* set the MODEM mode (02H normally) */
  733.         }
  734.         if(hwtype & HWDRSI) {                   /* this is a DRSI PC*Packet card */
  735.             ioaddr z8536 = chipbase + 7;        /* point to 8536 master ctrl reg */
  736.  
  737.             /* Initialize 8536 to perform its divide-by-32 function */
  738.             /* This part copied from N6TTO DRSI-driver */
  739.  
  740.             /* Start by forcing chip into known state */
  741.             VOID(RDREG(z8536));                 /* make sure pointer is written */
  742.             WRSCC(z8536,CIO_MICR,0x01);         /* force hardware reset */
  743.  
  744.             for (d = 0; d < 1000; d++) {        /* wait a while to be sure */
  745.                 dum *= 10;
  746.             }
  747.             WRSCC(z8536,CIO_MICR,0x00);         /* Clear reset and start */
  748.  
  749.             /* Wait for chip to come ready */
  750.             while (RDSCC(z8536,CIO_MICR) != 0x02) {
  751.                 dum *= 10;
  752.             }
  753.             WRSCC(z8536,CIO_MICR,0x26);         /* NV|CT_VIS|RJA */
  754.             WRSCC(z8536,CIO_MCCR,0xf4);         /* PBE|CT1E|CT2E|CT3E|PAE */
  755.  
  756.             WRSCC(z8536,CIO_CTMS1,0xe2);        /* Continuous, EOE, ECE, Pulse output */
  757.             WRSCC(z8536,CIO_CTMS2,0xe2);        /* Continuous, EOE, ECE, Pulse output */
  758.  
  759.             WRSCC(z8536,CIO_CT1MSB,0x00);       /* Load time constant CTC #1 */
  760.             WRSCC(z8536,CIO_CT1LSB,0x10);
  761.             WRSCC(z8536,CIO_CT2MSB,0x00);       /* Load time constant CTC #2 */
  762.             WRSCC(z8536,CIO_CT2LSB,0x10);
  763.  
  764.             WRSCC(z8536,CIO_IVR,0x06);
  765.  
  766.             /* Set port direction bits in port A and B           */
  767.             /* Data is input on bits d1 and d5, output on d0 and d4. */
  768.             /* The direction is set by 1 for input and 0 for output  */
  769.  
  770.             WRSCC(z8536,CIO_PDCA,0x22);
  771.             WRSCC(z8536,CIO_PDCB,0x22);
  772.  
  773.             WRSCC(z8536,CIO_CSR1,CIO_GCB|CIO_TCB); /* Start CTC #1 running */
  774.             WRSCC(z8536,CIO_CSR2,CIO_GCB|CIO_TCB); /* Start CTC #2 running */
  775.             }
  776.  
  777.             RESTORE();
  778.     }
  779.     Sccpolltab[chip][0] = 0;                    /* terminate the polling table */
  780.     Sccvecloc = intack;                         /* location of INTACK/vector read */
  781.     Sccmaxvec = 16 * nchips;                    /* upper limit on valid vector */
  782.     Orgivec = getirq(ivec);                     /* save original interrupt vector */
  783.  
  784.     if(intack) {                                /* INTACK method selected? */
  785.         /* set interrupt vector to INTACK-generating routine  */
  786.         setirq(ivec,sccvec);
  787.     } else {
  788.         /* set interrupt vector to polling routine */
  789.         setirq(ivec,sccnovec);
  790.     }
  791.     /* enable the interrupt  */
  792.     maskon(ivec);
  793.     return 0;
  794. }
  795.  
  796.  
  797. /* Attach an SCC channel to the system, or initialize SCC driver.
  798.  * operation depends on argv[2]:
  799.  * when "init", the SCC driver is initialized, and global information about
  800.  * the hardware is set up.
  801.  * argv[0]: hardware type, must be "scc"
  802.  * argv[1]: number of SCC chips we will support
  803.  * argv[2]: mode, must be: "init" in this case
  804.  * argv[3]: base address of SCC chip #0 (hex)
  805.  * argv[4]: spacing between SCC chip base addresses
  806.  * argv[5]: offset from chip base address to channel A control register
  807.  * argv[6]: offset from chip base address to channel B control register
  808.  * argv[7]: offset from each channel's control register to data register
  809.  * argv[8]: address of INTACK/Read Vector port. 0 to read from RR3A/RR2B
  810.  * argv[9]: CPU interrupt vector number for all connected SCCs
  811.  * argv[10]: clock frequency (PCLK/RTxC) of all SCCs in cycles per second
  812.  *         prefix with "p" for PCLK, "r" for RTxC clock (for baudrate gen)
  813.  * argv[11]: optional hardware type (for special features)
  814.  * argv[12]: optional extra parameter for special hardware
  815.  *
  816.  * otherwise, a single channel is attached using the specified parameters:
  817.  * argv[0]: hardware type, must be "scc"
  818.  * argv[1]: SCC channel number to attach, 0/1 for first chip A/B, 2/3 for 2nd...
  819.  * argv[2]: mode, can be: "slip", "kiss", "ax25"
  820.  * argv[3]: interface label, e.g., "sl0"
  821.  * argv[4]: maximum transmission unit, bytes
  822.  * argv[5]: interface speed, e.g, "1200". prefix with "d" when an external
  823.  *        divider is available to generate the TX clock.    When the clock
  824.  *        source is PCLK, this can be a /32 divider between TRxC and RTxC.
  825.  *        When the clock is at RTxC, the TX rate must be supplied at TRxC.
  826.  *        This is needed only for AX.25 fullduplex.
  827.  *        When this arg is given as "ext", the transmit and receive clock
  828.  *        are external, and the BRG and DPLL are not used.
  829.  *        On the BayCom-USCC card "ext" enables NRZ-mode for DF9IC-modem.
  830.  * argv[6]: buffer size
  831.  */
  832. int
  833. scc_attach(int argc,char **argv,void *p)
  834. {
  835.     struct iface *ifp;
  836.     struct sccchan *scc;
  837.     unsigned int chan, brgrate;
  838.     int pclk = 0, hwtype = 0, hwparam = 0, xdev;
  839.     char *ifn;
  840.  
  841.     /* first handle the special "init" mode, to initialize global stuff */
  842.     if(!strcmp(argv[2],"init")) {
  843.         if(argc < 11) {                 /* need at least argv[1]..argv[10] */
  844.             return -1;
  845.         }
  846.         switch(tolower(*argv[10])) {
  847.         case 'p':
  848.             pclk = 1;
  849.         case 'r':
  850.             argv[10]++;
  851.         }
  852.         if(argc > 11) {                 /* optional hardware type */
  853.             hwtype = htoi(argv[11]);    /* it is given in hex */
  854.         }
  855.         if(argc > 12) {                 /* optional hardware param */
  856.             hwparam = htoi(argv[12]);   /* also in hex */
  857.         }
  858.         if(Sccinfo.init){
  859.             tputs("SCC driver already initialized - nothing done\n");
  860.             return 1;
  861.         }
  862.         return scc_init(
  863.             atoi(argv[1]),(ioaddr)htol(argv[3]),atoi(argv[4]),atoi(argv[5]),
  864.             atoi(argv[6]),atoi(argv[7]),(ioaddr)htol(argv[8]),atoi(argv[9]),
  865.             atol(argv[10]),pclk,hwtype,hwparam);
  866.     }
  867.     /* not "init", so it must be a valid mode to attach a channel */
  868.     if(!*Mycall) {
  869.         tputs("Mycall not set\n");
  870.         return -1;
  871.     }
  872.     if(!Sccinfo.init){
  873.         tputs("First init SCC driver\n");
  874.         return -1;
  875.     }
  876.     if((chan = atoi(argv[1])) > Sccinfo.maxchan){
  877.         tprintf("SCC channel %d out of range\n",chan);
  878.         return -1;
  879.     }
  880.     if(Sccchan[chan] != NULLCHAN){
  881.         tprintf("SCC channel %d already attached\n",chan);
  882.         return -1;
  883.     }
  884.     /* create interface structure and fill in details */
  885.     ifp = (struct iface *) mxallocw(sizeof(struct iface));
  886.     ifp->addr = Ip_addr;
  887.     ifp->hwaddr = strxdup(Mycall);
  888.     ifp->dev = chan;
  889.     ifp->mtu = atoi(argv[4]);
  890.     ifp->name = strxdup(argv[3]);
  891.     ifp->stop = scc_stop;
  892.  
  893.     ifn = if_name(ifp," rx");
  894.  
  895.     scc = (struct sccchan *)mxallocw(sizeof(struct sccchan));
  896.     Sccchan[chan] = scc;        /* put addr in table for interrupts */
  897.  
  898.     scc->iface = ifp;
  899.     scc->ctrl = Sccinfo.iobase + (chan / 2) * Sccinfo.space + Sccinfo.off[chan % 2];
  900.     scc->data = scc->ctrl + Sccinfo.doff;
  901.  
  902.     switch(tolower(*argv[5])) {
  903.     case 'd':                   /* fulldup divider installed? */
  904.         scc->fulldup = 1;        /* set appropriate flag */
  905.         argv[5]++;              /* skip the 'd' */
  906.         break;
  907.     case 'e':                   /* external clocking? */
  908.         scc->extclock = 1;        /* set the flag */
  909.         argv[5]++;
  910.         break;
  911.     }
  912.     scc->bufsiz = atoi(argv[6]);
  913.  
  914.     switch(tolower(*argv[2])) {                   /* mode already checked above */
  915. #ifdef AX25
  916.     case 'a':                                   /* AX.25 */
  917.         scc_sdlc(scc);                          /* init SCC in SDLC mode */
  918.  
  919.         if(!scc->extclock) {
  920.             brgrate = scc_speed(scc,32,atol(argv[5]));          /* init SCC speed */
  921.             scc->speed = Sccinfo.clk / (64L * (brgrate + 2));   /* calc real speed */
  922.         }
  923.         brgrate = scc_speed(scc,32,atol(argv[5]));/* init SCC speed */
  924.         scc->speed = Sccinfo.clk / (64L * (brgrate + 2));/* calc real speed */
  925.  
  926.         setencap(ifp,"AX25");
  927.  
  928.         ifp->ioctl = scc_sioctl;
  929.         ifp->raw = scc_raw;
  930.  
  931.         /* default KISS Params */
  932.         scc->a.txdelay  = 25 * TPS/100;     /* 250 ms */
  933.         scc->a.persist  = 64;               /* 25% persistence */
  934.         scc->a.slottime = 10 * TPS/100;     /* 100 ms */
  935. #if TPS > 67
  936.         scc->a.tailtime = 3 * TPS/100;      /* 30 ms */
  937. #else
  938.         scc->a.tailtime = 2;                /* minimal reasonable value */
  939. #endif
  940.         scc->a.fulldup  = 0;                /* CSMA */
  941.         scc->a.waittime = 10 * TPS/100;     /* 100 ms */
  942.         scc->a.maxkeyup = 7;                /* 7 s */
  943.         scc->a.mintime  = 1;                /* 1 s */
  944.         scc->a.idletime = 120;              /* 120 s */
  945.         break;
  946.     case 'k':                               /* kiss */
  947.         scc_async(scc);                     /* init SCC in async mode */
  948.         brgrate = scc_speed(scc,16,atol(argv[5]));
  949.         scc->speed = Sccinfo.clk / (32L * (brgrate + 2));
  950.  
  951.         setencap(ifp,"AX25");
  952.  
  953.         ifp->ioctl = kiss_ioctl;
  954.         ifp->raw = kiss_raw;
  955.  
  956.         for(xdev = 0; xdev < SLIP_MAX; xdev++) {
  957.             if(Slip[xdev].iface == NULLIF) {
  958.                 break;
  959.             }
  960.         }
  961.         if(xdev >= SLIP_MAX) {
  962.             tprintf("Max %d KISS devices\n",SLIP_MAX);
  963.             goto quit;
  964.         }
  965.         Slip[xdev].iface = ifp;
  966.         Slip[xdev].type = CL_KISS;
  967.         Slip[xdev].send = scc_send;
  968.         Slip[xdev].get = get_scc;
  969.         
  970.         ifp->proc = newproc(ifn,256,asy_rx,xdev,NULL,NULL,0);
  971.         break;
  972. #endif
  973. #ifdef SLIP
  974.     case 's':                               /* slip */
  975.         scc_async(scc);                     /* init SCC in async mode */
  976.         brgrate = scc_speed(scc,16,atol(argv[5]));
  977.         scc->speed = Sccinfo.clk / (32L * (brgrate + 2));
  978.         
  979.         setencap(ifp,"SLIP");
  980.  
  981.         ifp->ioctl = scc_aioctl;
  982.         ifp->raw = slip_raw;
  983.         
  984.         for(xdev = 0; xdev < SLIP_MAX; xdev++) {
  985.             if(Slip[xdev].iface == NULLIF) {
  986.                 break;
  987.             }
  988.         }
  989.         if(xdev >= SLIP_MAX) {
  990.             tprintf("Max %d SLIP devices\n",SLIP_MAX);
  991.             goto quit;          
  992.         }
  993.         Slip[xdev].iface = ifp;
  994.         Slip[xdev].type = CL_SERIAL_LINE;
  995.         Slip[xdev].send = scc_send;
  996.         Slip[xdev].get = get_scc;
  997.         
  998.         ifp->proc = newproc(ifn,256,asy_rx,xdev,NULL,NULL,0);
  999.         break;
  1000. #endif
  1001. #ifdef NRS
  1002.     case 'n':                               /* nrs */
  1003.         scc_async(scc);                     /* init SCC in async mode */
  1004.         brgrate = scc_speed(scc,16,atol(argv[5]));
  1005.         scc->speed = Sccinfo.clk / (32L * (brgrate + 2));
  1006.         
  1007.         setencap(ifp,"AX25");
  1008.  
  1009.         ifp->ioctl = scc_aioctl;
  1010.         ifp->raw = nrs_raw;
  1011.  
  1012.         for(xdev = 0; xdev < NRS_MAX; xdev++) {
  1013.             if(Nrs[xdev].iface == NULLIF) {
  1014.                 break;
  1015.             }
  1016.         }
  1017.         if(xdev >= NRS_MAX) {
  1018.             tprintf("Max %d NRS devices\n",NRS_MAX);
  1019.             goto quit;          
  1020.         }
  1021.         Nrs[xdev].iface = ifp;
  1022.         Nrs[xdev].type = CL_NONE;
  1023.         Nrs[xdev].send = scc_send;
  1024.         Nrs[xdev].get = get_scc;
  1025.  
  1026.         ifp->rxproc = newproc(ifn,256,nrs_recv,xdev,NULL,NULL,0);
  1027.         break;
  1028. #endif
  1029.     default:
  1030. quit:    
  1031.         tprintf("Mode %s unknown for SCC iface\n",argv[2]);
  1032.         xfree(ifn);
  1033.         xfree(ifp->name);
  1034.         xfree(ifp->hwaddr);
  1035.         xfree(ifp);
  1036.         xfree(scc);
  1037.         Sccchan[chan] = NULLCHAN;
  1038.         return -1;
  1039.     }
  1040.     ifp->xdev = xdev;
  1041.     ifp->niface = Niface++;
  1042.     ifp->next = Ifaces;         /* link interface in list */
  1043.     Ifaces = ifp;
  1044.     return 0;
  1045. }
  1046.  
  1047. /* de-activate SCC channel */
  1048. static int
  1049. scc_stop(struct iface *ifp,int tmp)
  1050. {
  1051.     struct sccchan *scc = Sccchan[ifp->dev];
  1052.  
  1053.     DISABLE();
  1054.  
  1055.     VOID(RDREG(scc->ctrl));                     /* make sure pointer is written */
  1056.     wr(scc,R9,(ifp->dev % 2) ? CHRB : CHRA);    /* reset the channel */
  1057.  
  1058.     switch(ifp->iftype->type) {
  1059.     case CL_SERIAL_LINE:
  1060.     case CL_KISS:
  1061.         xfree(scc->fifo.buf);
  1062.         break;
  1063.     }
  1064.     xfree(scc);
  1065.     Sccchan[ifp->dev] = NULLCHAN;
  1066.     RESTORE();
  1067.     
  1068.     return 0;
  1069. }
  1070.  
  1071. /* de-activate SCC driver on program exit */
  1072. void
  1073. sccstop(void)
  1074. {
  1075.     if(Sccinfo.init) {                  /* was it initialized? */
  1076.         maskoff(Sccinfo.ivec);          /* disable the interrupt */
  1077.         setirq(Sccinfo.ivec,Orgivec);    /* restore original interrupt vector */
  1078.     }
  1079. }
  1080.  
  1081. /*----------------------------------------------------------------------*
  1082. * sccreact, reactivate scc after a temporary suspend, i.e swapping      *
  1083. * nos onto something not addressable (XMS,EMS,FILE)                     *
  1084. *  7-feb-1992   AA6HM/DK5DC      first shot                             *
  1085. * 13-feb-1992   AA6HM/DK5DC      added the istate = dirps() stuff       *
  1086. *-----------------------------------------------------------------------*/
  1087.  
  1088. void
  1089. sccreact()
  1090. {
  1091. int i_state = dirps();
  1092.  
  1093.    if(Sccinfo.init)   {
  1094.       if (Sccvecloc){                   /* INTACK method selected?      */
  1095.          /* set interrupt vector to INTACK-generating routine  */
  1096.          setirq(Sccinfo.ivec,sccvec);
  1097.       } else {
  1098.          /* set interrupt vector to polling routine */
  1099.          setirq(Sccinfo.ivec,sccnovec);
  1100.       }
  1101.       maskon(Sccinfo.ivec);
  1102.    }
  1103.    restore(i_state);
  1104. }
  1105.  
  1106.  
  1107. /* perform ioctl on SCC (async) channel
  1108.  * this is used for SLIP mode only, and will read/set the line speed
  1109.  */
  1110. static int32
  1111. scc_aioctl(struct iface *ifp,int cmd,int set,int32 val)
  1112. {
  1113.     if(cmd == PARAM_SPEED) {
  1114.         struct sccchan *scc = Sccchan[ifp->dev];
  1115.  
  1116.         if(set) {
  1117.             unsigned int brgrate = scc_speed(scc,16,val);
  1118.             scc->speed = Sccinfo.clk / (32L * (brgrate + 2));
  1119.         }
  1120.         return scc->speed;
  1121.     }
  1122.     return 0;
  1123. }
  1124.  
  1125. /* perform ioctl on SCC (sdlc) channel
  1126.  * this is used for AX.25 mode only, and will set the "kiss" parameters
  1127.  */
  1128. static int32
  1129. scc_sioctl(struct iface *ifp,int cmd,int set,int32 val)
  1130. {
  1131.     struct sccchan *scc = Sccchan[ifp->dev];
  1132.  
  1133.     switch(cmd) {
  1134.     case PARAM_SPEED:
  1135.         if(set) {
  1136.             if(val == 0) {
  1137.                 scc->extclock = 1;
  1138.             } else {
  1139.                 unsigned int brgrate = scc_speed(scc,32,val);/* init SCC speed */
  1140.                 scc->speed = Sccinfo.clk / (64L * (brgrate + 2));/* calc real speed */
  1141.             }
  1142.         }
  1143.         return scc->speed;
  1144.     case PARAM_TXDELAY:
  1145.         if(set) {
  1146.             scc->a.txdelay = val;
  1147.         }
  1148.         return scc->a.txdelay;
  1149.     case PARAM_PERSIST:
  1150.         if(set) {
  1151.             scc->a.persist = val;
  1152.         }
  1153.         return scc->a.persist;
  1154.     case PARAM_SLOTTIME:
  1155.         if(set) {
  1156.             if((scc->a.slottime = val) == 0) {
  1157.                 scc->a.slottime = 1;
  1158.             }
  1159.         }
  1160.         return scc->a.slottime;
  1161.     case PARAM_TXTAIL:
  1162.         if(set) {
  1163.             scc->a.tailtime = val;
  1164.         }
  1165.         return scc->a.tailtime;
  1166.     case PARAM_FULLDUP:
  1167.         if(set) {
  1168.             scc->a.fulldup = val;
  1169.         }
  1170.         return scc->a.fulldup;
  1171.     case PARAM_WAIT:
  1172.         if(set) {
  1173.             scc->a.waittime = val;
  1174.         }
  1175.         return scc->a.waittime;
  1176.     case PARAM_MAXKEY:
  1177.         if(set) {
  1178.             scc->a.maxkeyup = val;
  1179.         }
  1180.         return scc->a.maxkeyup;
  1181.     case PARAM_MIN:
  1182.         if(set) {
  1183.             scc->a.mintime = val;
  1184.         }
  1185.         return scc->a.mintime;
  1186.     case PARAM_IDLE:
  1187.         if(set) {
  1188.             scc->a.idletime = val;
  1189.         }
  1190.         return scc->a.idletime;
  1191.     case PARAM_DTR:
  1192.         if(set) {
  1193.             if(val) {
  1194.                 scc->wreg[R5] |= DTR;
  1195.             } else {
  1196.                 scc->wreg[R5] &= ~DTR;
  1197.             }
  1198.             DISABLE();
  1199.             if(scc->a.tstate == IDLE && scc->timercount == 0) {
  1200.                 scc->timercount = 1;    /* force an update */
  1201.             }
  1202.             RESTORE();
  1203.         }
  1204.         return (scc->wreg[R5] & DTR) ? 1 : 0;
  1205.     case PARAM_GROUP:
  1206.         if(set) {
  1207.             scc->group = (int)val;
  1208.         }
  1209.         return scc->group;
  1210.     }
  1211.     return -1;
  1212. }
  1213.  
  1214. /* show SCC status */
  1215. int
  1216. dosccstat(void)
  1217. {
  1218.     int i;
  1219.  
  1220.     if(!Sccinfo.init){
  1221.         tputs("SCC driver not initialized\n");
  1222.         return 0;
  1223.     }
  1224.     tputs("Ch Iface    Sent   Rcvd   Error Space Overr   Rxints   Txints   Exints   Spints\n");
  1225.  
  1226.     for(i = 0; i <= Sccinfo.maxchan; i++) {
  1227.         struct sccchan *scc;
  1228.         
  1229.         if((scc = Sccchan[i]) == NULLCHAN) {
  1230.             continue;
  1231.         }
  1232.         tprintf("%2d %-6s ",i,scc->iface->name);
  1233.         
  1234.         if(scc->int_receive == scc_asyrx) {
  1235.             tputs(" ** asynch **");
  1236.         } else {
  1237.             tprintf("%6lu %6lu",scc->enqueued,scc->rxframes);
  1238.         }    
  1239.         tprintf(" %7lu %5u %5u %8lu %8lu %8lu %8lu\n",
  1240.             scc->rxerrs,scc->nospace,scc->rovers,
  1241.             scc->rxints,scc->txints,scc->exints,scc->spints);
  1242.     }
  1243.     return 0;
  1244. }
  1245.  
  1246. /* send raw frame to SCC. used for AX.25 */
  1247. static int
  1248. scc_raw(struct iface *ifp,struct mbuf *bp)
  1249. {
  1250.     struct sccchan *scc = Sccchan[ifp->dev];
  1251.  
  1252.     dump(ifp,IF_TRACE_OUT,CL_AX25,bp);
  1253.  
  1254.     if(scc->tx_inhibit) {           /* transmitter inhibit */
  1255.         free_p(bp);
  1256.         return -1;
  1257.     }
  1258.     enqueue(&scc->sndq,bp);         /* enqueue packet */
  1259.     scc->enqueued++;
  1260.                                   
  1261.     DISABLE();
  1262.  
  1263.     if(scc->a.tstate == IDLE) {     /* when transmitter is idle */
  1264.         scc->a.tstate = DEFER;      /* start the key-up sequence */
  1265.         scc->a.maxdefer = TPS * scc->a.idletime / scc->a.slottime;
  1266.         scc->timercount = scc->a.waittime;
  1267.     }
  1268.     RESTORE();
  1269.     return 0;
  1270. }
  1271.  
  1272. static int 
  1273. scc_send(int dev,struct mbuf *bp)
  1274. {
  1275.     struct sccchan *scc = Sccchan[dev];
  1276.     
  1277.     enqueue(&scc->sndq,bp);
  1278.  
  1279.     if(scc->tbp == NULLBUF || scc->sndq != NULLBUF) {
  1280.         scc->tbp = dequeue(&scc->sndq);
  1281.         WRREG(scc->data,FR_END);
  1282.     }
  1283.     return 0;
  1284. }
  1285.  
  1286. /* SCC timer interrupt handler. 
  1287.  * Will be called every 1/TPS s by the routine systick in pc.c */ 
  1288. void 
  1289. scctimer(void) 
  1290. { 
  1291.     struct sccchan *scc, **sccp;
  1292.  
  1293.     DISABLE();
  1294.     
  1295.     for(sccp = Sccchan + Sccinfo.maxchan; sccp >= Sccchan; sccp--) { 
  1296.         if((scc = *sccp) != NULLCHAN 
  1297.           && scc->timercount != 0 
  1298.           && --(scc->timercount) == 0) { 
  1299.             /* handle an SCC timer event for this SCC channel 
  1300.              * this can only happen when the channel is AX.25 type 
  1301.              * (the SLIP/KISS driver does not use timers) */ 
  1302.             switch(scc->a.tstate) { 
  1303.             case IDLE:                              
  1304.                 /* it was idle, this is FULLDUP2 timeout */ 
  1305.                 scc_txoff(scc);                     /* switch-off the transmitter */ 
  1306.                 break; 
  1307.             case DEFER:                             /* trying to get the channel */ 
  1308.                 /* operation is as follows: 
  1309.                  * CSMA: when channel clear AND persistence randomgenerator 
  1310.                  *   wins, AND group restrictions allow it: 
  1311.                  *      keyup the transmitter 
  1312.                  *   if not, delay one SLOTTIME and try again 
  1313.                  * FULL: always keyup the transmitter */ 
  1314.                  if(scc->a.fulldup == 0) { 
  1315.                     Random = 21 * Random + 53; 
  1316.                     if(scc->status & DCD || scc->a.persist < Random) { 
  1317.                         /* defer transmission again. check for limit */ 
  1318. defer_it:               if(--(scc->a.maxdefer) == 0) { 
  1319.                             /* deferred too long. choice is to: 
  1320.                              * - throw away pending frames, or 
  1321.                              * - smash-on the transmitter and send them. 
  1322.                              * the first would be the choice in a clean 
  1323.                              * environment, but in the amateur radio world 
  1324.                              * a distant faulty station could tie us up 
  1325.                              * forever, so the second may be better... */ 
  1326. #ifdef THROW_AWAY_AFTER_DEFER_TIMEOUT 
  1327.                             struct mbuf *bp,*bp1;
  1328.  
  1329.                             while ((bp = scc->sndq) != NULLBUF) { 
  1330.                                 scc->sndq = scc->sndq->anext; 
  1331.                                 free_p(bp); 
  1332.                             } 
  1333. #else 
  1334.                             goto keyup;             /* just keyup the transmitter... */ 
  1335. #endif 
  1336.                         } 
  1337.                         scc->timercount = scc->a.slottime; 
  1338.                         break; 
  1339.                     } 
  1340.                     if(uchar(scc->group) != NOGROUP) { 
  1341.                         int i; 
  1342.                         struct sccchan *scc2;
  1343.  
  1344.                         for(i = 0; i <= Sccinfo.maxchan; i++) { 
  1345.                             if((scc2 = Sccchan[i]) != NULLCHAN 
  1346.                               && scc2 != scc 
  1347.                               && uchar(scc2->group) & uchar(scc->group) 
  1348.                               && ((scc->group & TXGROUP && scc2->wreg[R5] & RTS) 
  1349.                               || (scc->group & RXGROUP && scc2->status & DCD))) { 
  1350.                                 goto defer_it; 
  1351.                             } 
  1352.                         } 
  1353.                     } 
  1354.                 } 
  1355.             case KEYUP:                                         /*  keyup transmitter (note fallthrough) */ 
  1356. keyup:          if((scc->wreg[R5] & RTS) == 0) {                /* when not yet keyed */ 
  1357.                     scc->a.tstate = KEYWT; 
  1358.                     scc->timercount = scc->a.txdelay;           /* 0 if CTSwait */ 
  1359.                     
  1360.                     /* Switch the SCC to "transmit" mode */ 
  1361.                     if(!scc->fulldup && !scc->extclock) {       /* no fulldup divider? */ 
  1362.                         cl(scc,R3,RxENABLE);                    /* then switch off receiver */ 
  1363.                         cl(scc,R5,TxENAB);                      /* transmitter off during switch */ 
  1364.                         scc_speed(scc,1,scc->speed);            /* reprogram baudrate generator */ 
  1365.                         /* DPLL -> Rx clk, BRG -> Tx CLK, TxCLK -> TRxC pin */ 
  1366.                         wr(scc,R11,RCDPLL|TCBR|TRxCOI|TRxCBR); 
  1367.                     } 
  1368.                     or(scc,R5,RTS|TxENAB);                      /* set the RTS line and enable TX */ 
  1369.                     
  1370.                     if(Sccinfo.hwtype & HWPRIMUS) {             /* PRIMUS has another PTT bit... */ 
  1371.                         WRREG(scc->ctrl + 4,Sccinfo.hwparam | 0x80); /* set that bit! */ 
  1372.                     }
  1373.                     break; 
  1374.                 } 
  1375.                 /* when already keyed, directly fall through */ 
  1376.             case KEYWT:                             /* waited for CTS or TXDELAY */ 
  1377.                 /* when a frame is available (it should be...): 
  1378.                  * - dequeue it from the send queue 
  1379.                  * - reset the transmitter CRC generator 
  1380.                  * - set a timeout on transmission length, if defined 
  1381.                  * - send the first byte of the frame 
  1382.                  * - reset the EOM latch 
  1383.                  * when no frame available, proceed to TAIL handling */ 
  1384.                 if((scc->tbp = scc->sndq) != NULLBUF) { 
  1385.                     scc->sndq = scc->sndq->anext; 
  1386.                     WRREG(scc->ctrl,RES_Tx_CRC); 
  1387.                     scc->a.tstate = ACTIVE; 
  1388.                     scc->timercount = TPS * scc->a.maxkeyup; 
  1389.                     scc_sdlctx(scc); 
  1390.                     WRREG(scc->ctrl,RES_EOM_L); 
  1391.                     break; 
  1392.                 } 
  1393.                 /* when  no frame queued, fall through to TAIL case */ 
  1394.             case TAIL:                              /* at end of frame */ 
  1395.                 /* when fulldup is 0 or 1, switch off the transmitter. 
  1396.                  * when frames are still queued (because of transmit time limit), 
  1397.                  * restart the procedure to get the channel after MINTIME. 
  1398.                  * when fulldup is 2, the transmitter remains keyed and we 
  1399.                  * continue sending. IDLETIME is an idle timeout in this case. */ 
  1400.                 if(scc->a.fulldup < 2) { 
  1401.                     scc->a.tstate = IDLE; 
  1402.                     scc_txoff(scc);
  1403.  
  1404.                     if(scc->sndq != NULLBUF) { 
  1405.                         scc->a.tstate = DEFER; 
  1406.                         scc->a.maxdefer = TPS * scc->a.idletime / scc->a.slottime; 
  1407.                         scc->timercount = TPS * scc->a.mintime; 
  1408.                     } 
  1409.                     break; 
  1410.                 } 
  1411.                 if(scc->sndq != NULLBUF) {          /* still frames on the queue? */ 
  1412.                     scc->a.tstate = KEYWT;          /* continue sending */ 
  1413.                     scc->timercount = TPS * scc->a.mintime;     /* after mintime */ 
  1414.                 } else { 
  1415.                     scc->a.tstate = IDLE; 
  1416.                     scc->timercount = TPS * scc->a.idletime; 
  1417.                 } 
  1418.                 break; 
  1419.             case ACTIVE:                            /* max keyup time expired */ 
  1420.             case FLUSH:                             /* same while in flush mode */ 
  1421.                 break;                              /* no action required yet */ 
  1422.             default:                                /* unexpected state */ 
  1423.                 scc->a.tstate = IDLE;               /* that should not happen, but... */ 
  1424.                 scc_txoff(scc);                     /* at least stop the transmitter */ 
  1425.                 break; 
  1426.             } 
  1427.         } 
  1428.     } 
  1429.     RESTORE(); 
  1430. }
  1431.  
  1432. #endif
  1433.